ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪರಲ್ ಅವಧಿ: ಸಮಯದ ಮಧ್ಯಂತರ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೆಂಪರಲ್ API ದಿನಾಂಕಗಳು, ಸಮಯಗಳು ಮತ್ತು ಸಮಯದ ಮಧ್ಯಂತರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಆಧುನಿಕ ಮತ್ತು ಶಕ್ತಿಯುತ ಮಾರ್ಗವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. Temporal.Duration ವಸ್ತುವು ಸಮಯದ ಉದ್ದವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಸಮಯದ ಮಧ್ಯಂತರಗಳೊಂದಿಗೆ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಲೇಖನವು Temporal.Duration ನ ವಿವರಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ವಿವಿಧ ಉಪಯೋಗಗಳಿಗಾಗಿ ಅವಧಿಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು, ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಟೆಂಪರಲ್.ಡ್ಯೂರೇಷನ್ ಎಂದರೇನು?

Temporal.Duration ಸಮಯದ ವ್ಯಾಪ್ತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದನ್ನು ವರ್ಷಗಳು, ತಿಂಗಳುಗಳು, ದಿನಗಳು, ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು ಮತ್ತು ಒಂದು ಸೆಕೆಂಡಿನ ಭಾಗಗಳಲ್ಲಿ (ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳು, ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳು, ನ್ಯಾನೊ ಸೆಕೆಂಡ್‌ಗಳು) ವ್ಯಕ್ತಪಡಿಸುತ್ತದೆ. ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಬಿಂದುವನ್ನು ಪ್ರತಿನಿಧಿಸುವ Date ವಸ್ತುಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, Temporal.Duration ಸಮಯದ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು ISO 8601 ಅವಧಿಯ ಸ್ವರೂಪವನ್ನು ಅನುಸರಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, P1Y2M10DT2H30M ಎಂದರೆ 1 ವರ್ಷ, 2 ತಿಂಗಳುಗಳು, 10 ದಿನಗಳು, 2 ಗಂಟೆಗಳು ಮತ್ತು 30 ನಿಮಿಷಗಳು). ಟೆಂಪರಲ್ API ಅನ್ನು ಲೆಗಸಿ Date ವಸ್ತುವಿಗಿಂತ ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತ ಮತ್ತು ದೋಷ-ಮುಕ್ತವಾಗಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ಟೆಂಪರಲ್.ಡ್ಯೂರೇಷನ್ ವಸ್ತುಗಳನ್ನು ರಚಿಸುವುದು

Temporal.Duration ವಸ್ತುಗಳನ್ನು ರಚಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ:

1. ಒಂದು ಸಾಮಾನ್ಯ ವಸ್ತುವಿನಿಂದ

ಬಯಸಿದ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಒಂದು ವಸ್ತುವನ್ನು ರವಾನಿಸುವ ಮೂಲಕ ನೀವು ಒಂದು ಅವಧಿಯನ್ನು ರಚಿಸಬಹುದು:

            const duration = new Temporal.Duration(1, 2, 10, 2, 30, 0, 0, 0);
console.log(duration.toString()); // Output: P1Y2M10DT2H30M
            

              
                Copy
              
            
          

ಇದು 1 ವರ್ಷ, 2 ತಿಂಗಳುಗಳು, 10 ದಿನಗಳು, 2 ಗಂಟೆಗಳು ಮತ್ತು 30 ನಿಮಿಷಗಳ ಅವಧಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ವಾದಗಳು ಈ ಕೆಳಗಿನ ಕ್ರಮಕ್ಕೆ ಅನುಗುಣವಾಗಿವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ: years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds.

2. ISO 8601 ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ

ನೀವು Temporal.Duration.from() ಅನ್ನು ಬಳಸಿಕೊಂಡು ISO 8601 ಅವಧಿಯ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಅವಧಿಯನ್ನು ಸಹ ರಚಿಸಬಹುದು:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.toString()); // Output: P1Y2M10DT2H30M

            

              
                Copy
              
            
          

ಸ್ಟ್ರಿಂಗ್ ಸ್ವರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಅಥವಾ ಬಾಹ್ಯ ಮೂಲದಿಂದ ಸ್ವೀಕರಿಸಿದ ಅವಧಿಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

3. add() ಮತ್ತು subtract() ವಿಧಾನಗಳನ್ನು Temporal.Instant, Temporal.ZonedDateTime, ಇತ್ಯಾದಿಗಳೊಂದಿಗೆ ಬಳಸುವುದು

ನೀವು ಇತರ ಟೆಂಪರಲ್ ಪ್ರಕಾರಗಳಿಗೆ (Temporal.Instant ಅಥವಾ Temporal.ZonedDateTime ನಂತಹ) Temporal.Duration ಅನ್ನು ಸೇರಿಸಿದಾಗ ಅಥವಾ ಕಳೆದಾಗ, ನೀವು ಅವುಗಳನ್ನು ಕಳೆದರೆ ಎರಡು ಸಮಯ ಬಿಂದುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಪ್ರತಿನಿಧಿಸುವ Temporal.Duration ಅನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

            const now = Temporal.Now.zonedDateTimeISO();
const later = now.add({ hours: 5 });
const duration = later.since(now);
console.log(duration.toString()); // Output: PT5H
            

              
                Copy
              
            
          

ಅವಧಿ ಘಟಕಗಳಿಗೆ ಪ್ರವೇಶ

ನೀವು ಅದರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು Temporal.Duration ವಸ್ತುವಿನ ವೈಯಕ್ತಿಕ ಘಟಕಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
console.log(duration.years);      // Output: 1
console.log(duration.months);     // Output: 2
console.log(duration.days);       // Output: 10
console.log(duration.hours);      // Output: 2
console.log(duration.minutes);     // Output: 30
console.log(duration.seconds);     // Output: 0
console.log(duration.milliseconds); // Output: 0
console.log(duration.microseconds); // Output: 0
console.log(duration.nanoseconds);  // Output: 0

            

              
                Copy
              
            
          

ಅವಧಿಗಳೊಂದಿಗೆ ಅಂಕಗಣಿತವನ್ನು ನಿರ್ವಹಿಸುವುದು

Temporal.Duration ವಸ್ತುಗಳು add() ಮತ್ತು subtract() ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸೇರ್ಪಡೆ ಮತ್ತು ವ್ಯವಕಲನವನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ. ಈ ವಿಧಾನಗಳು ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಹೊಸ Temporal.Duration ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ.

            const duration1 = Temporal.Duration.from("P1Y2M");
const duration2 = Temporal.Duration.from("P3M4D");

const addedDuration = duration1.add(duration2);
console.log(addedDuration.toString()); // Output: P1Y5M4D

const subtractedDuration = duration1.subtract(duration2);
console.log(subtractedDuration.toString()); // Output: P10M26D

            

              
                Copy
              
            
          

ನೀವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳಿಗಾಗಿ ಈ ವಿಧಾನಗಳನ್ನು ಸರಪಳಿಯಾಗಿ ಮಾಡಬಹುದು:

            const duration = Temporal.Duration.from("P1D").add({ hours: 12 }).subtract({ minutes: 30 });
console.log(duration.toString()); // Output: P1DT11H30M

            

              
                Copy
              
            
          

negated() ವಿಧಾನವು ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ನಿರಾಕರಿಸುವುದರೊಂದಿಗೆ ಹೊಸ Temporal.Duration ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Output: -P1Y2M10DT2H30M

            

              
                Copy
              
            
          

abs() ವಿಧಾನವು ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಧನಾತ್ಮಕ ಮೌಲ್ಯಗಳಾಗಿ (ಸಂಪೂರ್ಣ ಮೌಲ್ಯಗಳು) ಹೊಂದಿರುವ ಹೊಸ Temporal.Duration ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

            const duration = Temporal.Duration.from("-P1Y2M10DT2H30M");
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Output: P1Y2M10DT2H30M

            

              
                Copy
              
            
          

with() ವಿಧಾನವು ಕೆಲವು ಅಥವಾ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಸ ಮೌಲ್ಯಗಳಿಗೆ ಬದಲಾಯಿಸಿದ ಹೊಸ Temporal.Duration ನಿದರ್ಶನವನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ವಾದ ವಸ್ತುವಿನಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಅವಧಿಯ ಮೂಲ ಮೌಲ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

            const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const newDuration = duration.with({ years: 2, days: 5 });
console.log(newDuration.toString()); // Output: P2Y2M5DT2H30M
            

              
                Copy
              
            
          

ಅವಧಿಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸುವುದು

ಅವಧಿಗಳನ್ನು ಕೆಲವೊಮ್ಮೆ ಸಾಮಾನ್ಯವಲ್ಲದ ರೂಪದಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಬಹುದು (ಉದಾಹರಣೆಗೆ, P1Y12M, ಇದನ್ನು P2Y ಗೆ ಸರಳಗೊಳಿಸಬಹುದು). normalized() ವಿಧಾನವು ಅವಧಿಯನ್ನು ಅದರ ಅತ್ಯಂತ ಕಾಂಪ್ಯಾಕ್ಟ್ ರೂಪಕ್ಕೆ ಸರಳಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಬದಲಾಗುವ ತಿಂಗಳ ಉದ್ದಗಳ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉಲ್ಲೇಖ ದಿನಾಂಕದ ಅಗತ್ಯವಿದೆ. ಸರಿಯಾಗಿ ಸಾಮಾನ್ಯಗೊಳಿಸಲು, ನಿಮಗೆ Temporal.PlainDate, Temporal.ZonedDateTime ಅಥವಾ Temporal.Instant ನಿದರ್ಶನದ ಅಗತ್ಯವಿದೆ.

ಉದಾಹರಣೆಗೆ, ತಿಂಗಳುಗಳು ಮತ್ತು ದಿನಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅವಧಿಯನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಲು ಉಲ್ಲೇಖ ದಿನಾಂಕದ ಅಗತ್ಯವಿದೆ:

            const duration = Temporal.Duration.from("P1M32D");
const referenceDate = Temporal.PlainDate.from("2024-01-01");
const normalizedDuration = duration.normalized({ relativeTo: referenceDate });
console.log(normalizedDuration.toString()); // Output: P2M1D

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಜನವರಿ 1, 2024 ಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ ಅವಧಿ P1M32D ಅನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಲಾಗಿದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ P2M1D ಆಗುತ್ತದೆ, ಏಕೆಂದರೆ ಜನವರಿಯಲ್ಲಿ 31 ದಿನಗಳಿವೆ.

ನೀವು ಸಮಯದ ಘಟಕಗಳನ್ನು ಮಾತ್ರ ವ್ಯವಹರಿಸುತ್ತಿದ್ದರೆ (ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು, ಇತ್ಯಾದಿ), ನೀವು ಉಲ್ಲೇಖ ದಿನಾಂಕವಿಲ್ಲದೆ ಸಾಮಾನ್ಯಗೊಳಿಸಬಹುದು:

            const duration = Temporal.Duration.from("PT25H61M");
const normalizedDuration = duration.normalized({ relativeTo: null }); //or omit relativeTo argument
console.log(normalizedDuration.toString()); // Output: P1DT2H1M
            

              
                Copy
              
            
          

ಅವಧಿಗಳನ್ನು ಹೋಲಿಸುವುದು

ನೀವು compare() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಅವಧಿಗಳನ್ನು ಹೋಲಿಸಬಹುದು. ಈ ವಿಧಾನವು ಹಿಂದಿರುಗಿಸುತ್ತದೆ:

• ಮೊದಲ ಅವಧಿಯು ಎರಡನೆಯದಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದ್ದರೆ -1.
• ಅವಧಿಗಳು ಸಮಾನವಾಗಿದ್ದರೆ 0.
• ಮೊದಲ ಅವಧಿಯು ಎರಡನೆಯದಕ್ಕಿಂತ ಉದ್ದವಾಗಿದ್ದರೆ 1.

            const duration1 = Temporal.Duration.from("P1Y");
const duration2 = Temporal.Duration.from("P6M");

const comparisonResult = Temporal.Duration.compare(duration1, duration2);
console.log(comparisonResult); // Output: 1
            

              
                Copy
              
            
          

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

1. ಈವೆಂಟ್ ವರೆಗಿನ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು

ನೀವು ನಿರ್ದಿಷ್ಟ ಈವೆಂಟ್ ವರೆಗೆ ಉಳಿದಿರುವ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಪಡೆಯಲು Temporal.Now.zonedDateTimeISO() ಅನ್ನು ಬಳಸಿ, ಮತ್ತು ಈವೆಂಟ್‌ನ ದಿನಾಂಕವನ್ನು ಕಳೆಯಿರಿ. ಈವೆಂಟ್‌ನ ದಿನಾಂಕವು ಮುಗಿದಿದ್ದರೆ, ಔಟ್‌ಪುಟ್ ನಕಾರಾತ್ಮಕವಾಗಿರುತ್ತದೆ.

            const eventDate = Temporal.ZonedDateTime.from({ timeZone: 'America/Los_Angeles', year: 2024, month: 12, day: 25, hour: 9, minute: 0, second: 0 });
const now = Temporal.Now.zonedDateTimeISO('America/Los_Angeles');

const durationUntilEvent = eventDate.since(now);

console.log(durationUntilEvent.toString()); // Output: e.g., P262DT14H30M (depending on the current date and time)
            

              
                Copy
              
            
          

2. ಪ್ರಾಜೆಕ್ಟ್ ಕಾರ್ಯ ಅವಧಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು

ಪ್ರಾಜೆಕ್ಟ್ ನಿರ್ವಹಣೆಯಲ್ಲಿ, ಕಾರ್ಯಗಳ ಅಂದಾಜು ಅಥವಾ ನಿಜವಾದ ಅವಧಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ನೀವು Temporal.Duration ಅನ್ನು ಬಳಸಬಹುದು.

            const task1EstimatedDuration = Temporal.Duration.from("PT8H"); // 8 hours
const task2EstimatedDuration = Temporal.Duration.from("PT16H"); // 16 hours

const totalEstimatedDuration = task1EstimatedDuration.add(task2EstimatedDuration);
console.log(`Total estimated duration: ${totalEstimatedDuration.toString()}`); // Output: Total estimated duration: P1DT
            

              
                Copy
              
            
          

3. ವಯಸ್ಸನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು

ವಯಸ್ಸನ್ನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಅಧಿಕ ವರ್ಷಗಳು ಮತ್ತು ಸಮಯ ವಲಯಗಳನ್ನು ಪರಿಗಣಿಸಬೇಕಾದರೆ, Temporal.Duration ಸಮಂಜಸವಾದ ಅಂದಾಜನ್ನು ಒದಗಿಸುತ್ತದೆ:

            const birthDate = Temporal.PlainDate.from("1990-05-15");
const currentDate = Temporal.PlainDate.from("2024-01-20");

const ageDuration = currentDate.since(birthDate, { smallestUnit: 'years' });
console.log(`Estimated age: ${ageDuration.years} years`); // Output: Estimated age: 33 years
            

              
                Copy
              
            
          

4. ಮಾನವ-ಓದಬಲ್ಲ ಅವಧಿಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವುದು

ಹೆಚ್ಚಾಗಿ, ನೀವು ಅವಧಿಗಳನ್ನು ಮಾನವ-ಓದಬಲ್ಲ ಸ್ವರೂಪದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಬೇಕಾಗುತ್ತದೆ. Temporal.Duration ಅಂತರ್ನಿರ್ಮಿತ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೂ, ನೀವು ಕಸ್ಟಮ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ತರ್ಕವನ್ನು ರಚಿಸಬಹುದು:

            function formatDuration(duration) {
  const parts = [];
  if (duration.years) parts.push(`${duration.years} year${duration.years > 1 ? 's' : ''}`);
  if (duration.months) parts.push(`${duration.months} month${duration.months > 1 ? 's' : ''}`);
  if (duration.days) parts.push(`${duration.days} day${duration.days > 1 ? 's' : ''}`);
  if (duration.hours) parts.push(`${duration.hours} hour${duration.hours > 1 ? 's' : ''}`);
  if (duration.minutes) parts.push(`${duration.minutes} minute${duration.minutes > 1 ? 's' : ''}`);
  if (duration.seconds) parts.push(`${duration.seconds} second${duration.seconds > 1 ? 's' : ''}`);

  return parts.join(', ');
}

const duration = Temporal.Duration.from("P1Y2M10DT2H30M");
const formattedDuration = formatDuration(duration);
console.log(formattedDuration); // Output: 1 year, 2 months, 10 days, 2 hours, 30 minutes
            

              
                Copy
              
            
          

ಸುಧಾರಿತ ಬಳಕೆ ಮತ್ತು ಪರಿಗಣನೆಗಳು

1. ಸಮಯ ವಲಯ ನಿರ್ವಹಣೆ

ಸಮಯ ವಲಯದ ಗಡಿಗಳನ್ನು ದಾಟುವ ಅಥವಾ ಹಗಲು ಉಳಿತಾಯ ಸಮಯ ಪರಿವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಸಮಯದ ಮಧ್ಯಂತರಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ, ನಿಖರವಾದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು Temporal.ZonedDateTime ಅನ್ನು ಬಳಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. Temporal.PlainDate ಮತ್ತು Temporal.PlainTime ಅನ್ನು ಬಳಸುವುದರಿಂದ ಯಾವುದೇ ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

2. ಚಿಕ್ಕ ಘಟಕ ಮತ್ತು ದುಂಡುಗೊಳಿಸುವಿಕೆ

since() ಮತ್ತು until() ವಿಧಾನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಫಲಿತಾಂಶದ ಅವಧಿಗೆ ಚಿಕ್ಕ ಘಟಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಆಯ್ಕೆಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಈವೆಂಟ್ ವರೆಗಿನ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು *until* ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ದಿನಗಳಿಗೆ ಸೀಮಿತಗೊಳಿಸುವುದು.

            const eventDate = Temporal.PlainDate.from("2024-12-25");
const now = Temporal.PlainDate.from("2024-01-20");

const durationUntilEvent = now.until(eventDate, { smallestUnit: 'days' });

console.log(durationUntilEvent.toString()); //example output PT340D
            

              
                Copy
              
            
          

3. ಅಧಿಕ ಸೆಕೆಂಡುಗಳು

ಟೆಂಪರಲ್ ಸ್ಥಳೀಯವಾಗಿ ಅಧಿಕ ಸೆಕೆಂಡುಗಳನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ. ನಿಮಗೆ ವಿಪರೀತ ನಿಖರತೆ ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ ಅಧಿಕ ಸೆಕೆಂಡುಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ.

4. IANA ಸಮಯ ವಲಯಗಳು

ಟೆಂಪರಲ್ API IANA (ಇಂಟರ್ನೆಟ್ ಅಸೈನ್‌ಡ್ ನಂಬರ್ಸ್ ಅಥಾರಿಟಿ) ಸಮಯ ವಲಯ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅವಲಂಬಿಸಿದೆ. ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳನ್ನು ನಿಖರವಾಗಿ ನಿರ್ವಹಿಸಲು ನಿಮ್ಮ ಪರಿಸರವು IANA ಡೇಟಾಬೇಸ್‌ನ ನವೀಕೃತ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಅವಧಿಯ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗಾಗಿ ISO 8601 ಸ್ವರೂಪವನ್ನು ಬಳಸಿ: ಇದು ಸ್ಥಿರತೆ ಮತ್ತು ಪರಸ್ಪರ ಕಾರ್ಯಸಾಧ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಸೂಕ್ತವಾದ ಟೆಂಪರಲ್ ಪ್ರಕಾರವನ್ನು ಆರಿಸಿ: ಸಮಯ ವಲಯ ಬೆಂಬಲದ ಅಗತ್ಯವಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ Temporal.PlainDate, Temporal.PlainTime, Temporal.ZonedDateTime, ಅಥವಾ Temporal.Instant ಅನ್ನು ಬಳಸಿ.
• ಅಗತ್ಯವಿದ್ದಾಗ ಅವಧಿಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಿ: ಸಾಮಾನ್ಯೀಕರಣವು ಅವಧಿಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಹೋಲಿಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
• ಸಮಯ ವಲಯಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸಿ: ಸಮಯ ವಲಯ ಪರಿವರ್ತನೆಗಳು ಸಂಕೀರ್ಣವಾಗಬಹುದು, ಆದ್ದರಿಂದ Temporal.ZonedDateTime ಅನ್ನು ಬಳಸಿ ಮತ್ತು ಹಗಲು ಉಳಿತಾಯ ಸಮಯ ಪರಿವರ್ತನೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ.
• ಚಿಕ್ಕ ಘಟಕವನ್ನು ಪರಿಗಣಿಸಿ: ಅವಧಿಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಾಗ, ಬಯಸಿದ ಮಟ್ಟದ ನಿಖರತೆಯನ್ನು ಪಡೆಯಲು ಚಿಕ್ಕ ಘಟಕವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ.
• ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ: ಅವಧಿಯ ಲೆಕ್ಕಾಚಾರಗಳು ನಿಖರವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.

ಸಾಮಾನ್ಯ ಅಪಾಯಗಳು

• ಸಮಯ ವಲಯಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದು: ಸಮಯ ವಲಯಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲು ವಿಫಲವಾದರೆ, ವಿಶೇಷವಾಗಿ ವಿಭಿನ್ನ ಸ್ಥಳಗಳಲ್ಲಿನ ಈವೆಂಟ್‌ಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ, ತಪ್ಪಾದ ಅವಧಿಯ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
• ಲೆಗಸಿ ದಿನಾಂಕ ವಸ್ತುವನ್ನು ಬಳಸುವುದು: ಲೆಗಸಿ Date ವಸ್ತುವು ಅದರ ವಿಲಕ್ಷಣತೆಗಳು ಮತ್ತು ಅಸ್ಥಿರತೆಗಳಿಗೆ ಹೆಸರುವಾಸಿಯಾಗಿದೆ. ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ನಿರ್ವಹಣೆಗಾಗಿ ಟೆಂಪರಲ್ API ಅನ್ನು ಆರಿಸಿ.
• ಅವಧಿಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸದಿರುವುದು: ಅವಧಿಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸದಿರುವುದು ಹೋಲಿಕೆಗಳು ಮತ್ತು ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣಗೊಳಿಸಬಹುದು.
• ತಪ್ಪಾದ ISO 8601 ಸ್ವರೂಪ: ಅಮಾನ್ಯವಾದ ISO 8601 ಅವಧಿಯ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬಳಸುವುದು ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ವಿವಿಧ ಸಂಸ್ಕೃತಿಗಳಲ್ಲಿ ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆ ಪ್ರಕರಣಗಳು

ಟೆಂಪರಲ್ API ಸಮಯ ವಲಯ ವ್ಯತ್ಯಾಸಗಳು ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳು ಮುಖ್ಯವಾಗಿರುವ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

• ಜಾಗತಿಕ ಈವೆಂಟ್ ವೇಳಾಪಟ್ಟಿ: ಬಹು ಸಮಯ ವಲಯಗಳಲ್ಲಿ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿಖರವಾಗಿ ನಿಗದಿಪಡಿಸುವುದು, ಹಗಲು ಉಳಿತಾಯ ಸಮಯ ಪರಿವರ್ತನೆಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವುದು. ಉದಾಹರಣೆಗೆ, 9:00 AM PST ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುವ ವೆಬ್‌ನಾರ್ ಅನ್ನು ನಿಗದಿಪಡಿಸುವುದು ಮತ್ತು CET, JST ಮತ್ತು AEDT ನಂತಹ ವಿವಿಧ ಸಮಯ ವಲಯಗಳಲ್ಲಿ ಅನುಗುಣವಾದ ಪ್ರಾರಂಭ ಸಮಯವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು.
• ಅಂತರರಾಷ್ಟ್ರೀಯ ಪ್ರಯಾಣ ಯೋಜನೆ: ಲೇಓವರ್‌ಗಳು ಮತ್ತು ಸಮಯ ವಲಯ ಬದಲಾವಣೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಪ್ರಯಾಣದ ಅವಧಿಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು. ಇದು ಪ್ರಯಾಣ ಮಾರ್ಗಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಮತ್ತು ವಿಮಾನ ವೇಳಾಪಟ್ಟಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನ್ಯೂಯಾರ್ಕ್‌ನಿಂದ ಟೋಕಿಯೊಗೆ ಪ್ರಯಾಣದ ಒಟ್ಟು ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು, ಲಂಡನ್‌ನಲ್ಲಿ ಲೇಓವರ್ ಅನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ಸಮಯ ವಲಯ ವ್ಯತ್ಯಾಸಗಳಿಗೆ ಹೊಂದಾಣಿಕೆ ಮಾಡುವುದು.
• ಜಾಗತಿಕ ಇ-ಕಾಮರ್ಸ್: ಬಳಕೆದಾರರ ಸ್ಥಳೀಯ ಸಮಯ ವಲಯದಲ್ಲಿ ಅಂದಾಜು ವಿತರಣಾ ಸಮಯವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು. ಇದಕ್ಕೆ ಮೂಲ ಸಮಯ ವಲಯ, ಶಿಪ್ಪಿಂಗ್ ಅವಧಿ ಮತ್ತು ಗಮ್ಯಸ್ಥಾನ ಸಮಯ ವಲಯವನ್ನು ಪರಿಗಣಿಸುವುದು ಅಗತ್ಯವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಜರ್ಮನಿಯಲ್ಲಿನ ಗೋದಾಮಿನಿಂದ ಆಸ್ಟ್ರೇಲಿಯಾದಲ್ಲಿನ ಗ್ರಾಹಕರಿಗೆ ರವಾನೆಯಾದ ಒಂದು ವಸ್ತುವನ್ನು 7 ದಿನಗಳ ಅಂದಾಜು ವಿತರಣಾ ಸಮಯದೊಂದಿಗೆ ಗ್ರಾಹಕರ ಸ್ಥಳೀಯ ಸಮಯದಲ್ಲಿ ಪ್ರದರ್ಶಿಸುವುದು.
• ಅಂತರ-ಸಾಂಸ್ಕೃತಿಕ ಹಣಕಾಸು ವಹಿವಾಟುಗಳು: ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳಲ್ಲಿ ಬಡ್ಡಿ ಸಂಗ್ರಹಣೆ ಅಥವಾ ಪಾವತಿ ಗಡುವುಗಳನ್ನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತಿಯೊಂದು ದೇಶದಲ್ಲಿ ವಿಭಿನ್ನ ಕೆಲಸದ ದಿನಗಳು ಮತ್ತು ರಜಾದಿನಗಳನ್ನು ಪರಿಗಣಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಸಿಂಗಾಪುರದ ಸಾರ್ವಜನಿಕ ರಜಾದಿನಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು ಸಿಂಗಾಪುರದಲ್ಲಿನ ಸಾಲದ ಮೇಲೆ ಸಂಗ್ರಹವಾದ ಬಡ್ಡಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು.
• ಬಹುಸಾಂಸ್ಕೃತಿಕ ಕ್ಯಾಲೆಂಡರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು: ಇಸ್ಲಾಮಿಕ್ ಅಥವಾ ಹೀಬ್ರೂ ಕ್ಯಾಲೆಂಡರ್‌ನಂತಹ ವಿವಿಧ ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಬೆಂಬಲಿಸುವುದು ಮತ್ತು ಈ ಕ್ಯಾಲೆಂಡರ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಈವೆಂಟ್ ಅವಧಿಗಳು ಮತ್ತು ಜ್ಞಾಪನೆಗಳನ್ನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು.
• ಜಾಗತಿಕ ಪ್ರಾಜೆಕ್ಟ್ ನಿರ್ವಹಣೆ: ವಿತರಿಸಲಾದ ತಂಡಗಳಲ್ಲಿ ಪ್ರಾಜೆಕ್ಟ್ ಕಾರ್ಯ ಅವಧಿಗಳು ಮತ್ತು ಗಡುವುಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು, ವಿಭಿನ್ನ ಕೆಲಸದ ವೇಳಾಪಟ್ಟಿಗಳು ಮತ್ತು ಸಮಯ ವಲಯಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವುದು.

ತೀರ್ಮಾನ

Temporal.Duration ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಮಯದ ಮಧ್ಯಂತರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ದೃಢವಾದ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅದರ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನೀವು ನಿಖರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಅವಧಿ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ನಿರ್ವಹಿಸಬಹುದು. ಟೆಂಪರಲ್ API ಅನ್ನು ಸ್ವೀಕರಿಸುವುದರಿಂದ ಕ್ಲೀನರ್, ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಮತ್ತು ಲೆಗಸಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ನಿರ್ವಹಣೆಗೆ ಸಂಬಂಧಿಸಿದ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ನೀವು ಟೆಂಪರಲ್ API ಗೆ ಆಳವಾಗಿ ಇಳಿದಂತೆ, ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಅದರ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ವಿಭಿನ್ನ ಸನ್ನಿವೇಶಗಳನ್ನು ಪ್ರಯೋಗಿಸಲು ನೆನಪಿಡಿ. ಅದರ ಆಧುನಿಕ ವಿನ್ಯಾಸ ಮತ್ತು ಸಮಗ್ರ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ, ಟೆಂಪರಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಿನಾಂಕಗಳು, ಸಮಯಗಳು ಮತ್ತು ಅವಧಿಗಳನ್ನು ನಾವು ನಿರ್ವಹಿಸುವ ವಿಧಾನವನ್ನು ಕ್ರಾಂತಿಗೊಳಿಸಲು ಸಿದ್ಧವಾಗಿದೆ.